home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 43 / Mac Magazin and MacEasy Magazine CD - Issue 43.iso / Software / Multimedia / Sound / PlayerPRO 4.6 Dev.Kit / MADH Library 4.6 / MADLibrary Source / DeluxeDriver.c < prev    next >
Encoding:
Text File  |  1998-01-23  |  21.2 KB  |  724 lines  |  [TEXT/CWIE]
  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 4.6 - DRIVER SOURCE CODE -
  4. //
  5. //    Library Version 4.6
  6. //
  7. //    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
  15. //
  16. //    Thank you for your interest in PlayerPRO !
  17. //
  18. //    FAX:            (+41 22) 346 11 97
  19. //    PHONE:             (+41 79) 203 74 62
  20. //    Internet:         rosset@dial.eunet.ch or RossetAntoine@bluewin.ch
  21. //
  22. /********************                        ***********************/
  23.  
  24. #include "RDriver.h"
  25. #include "RDriverInt.h"
  26.  
  27. void MADCreateOverShoot( MADDriverRec *intDriver)
  28. {
  29.     long    i, x;
  30.  
  31.     switch( intDriver->DriverSettings.outPutBits)
  32.     {
  33.         case 16:
  34.             if( intDriver->DriverSettings.MicroDelay)    intDriver->DASCBuffer = (long*) MADNewPtrClear( ( (long) intDriver->ASCBUFFER * 8L) + intDriver->MDelay*2L*8L, intDriver->lib);
  35.             else                                        intDriver->DASCBuffer = (long*) MADNewPtrClear( ( (long) intDriver->ASCBUFFER * 8L), intDriver->lib);        // Le Clear est indispensable !!
  36.         break;
  37.         
  38.         case 8:
  39.             if( intDriver->DriverSettings.MicroDelay)    intDriver->DASCBuffer8 = (short*) MADNewPtrClear( ( (long) intDriver->ASCBUFFER * 4L) + intDriver->MDelay*2L*4L, intDriver->lib);
  40.             else                                        intDriver->DASCBuffer8 = (short*) MADNewPtrClear( ( (long) intDriver->ASCBUFFER * 4L), intDriver->lib);    // Le Clear est indispensable !!
  41.             
  42.             intDriver->OverShoot = (Ptr) MADNewPtrClear( 256L * 32L, intDriver->lib);
  43.     
  44.             for( i = 0; i < 256L * 16L; i++)                        intDriver->OverShoot[ i] = 0;
  45.             for( i = 256L * 16L, x = 0; i < 256L * 17L; i++, x++)    intDriver->OverShoot[ i] = x;
  46.             for( i = 256L * 17L; i < 256L * 32L; i++)                intDriver->OverShoot[ i] = 0xFF;
  47.             
  48.             
  49.             intDriver->OverShoot += 256L*16L;
  50.             intDriver->OverShoot += 128L;
  51.         break;
  52.     }
  53. }
  54.  
  55. void MADKillOverShoot( MADDriverRec *intDriver)
  56. {
  57.     switch( intDriver->DriverSettings.outPutBits)
  58.     {
  59.         case 16:
  60.             if( intDriver->DASCBuffer != 0L) DisposePtr( (Ptr) intDriver->DASCBuffer);
  61.             intDriver->DASCBuffer = 0L;
  62.         break;
  63.  
  64.         case 8:
  65.             if( intDriver->OverShoot != 0L)
  66.             {
  67.                 intDriver->OverShoot -= 128L;
  68.                 intDriver->OverShoot -= 256L*16L;
  69.                 DisposePtr( (Ptr) intDriver->OverShoot);
  70.                 intDriver->OverShoot = 0L;
  71.             }
  72.             
  73.             if( intDriver->DASCBuffer8 != 0L) DisposePtr( (Ptr) intDriver->DASCBuffer8);
  74.             intDriver->DASCBuffer8 = 0L;
  75.         break;
  76.     }
  77. }
  78.  
  79. void Sampler16AddDeluxe( Channel *curVoice, register long    *ASCBuffer, MADDriverRec *intDriver)
  80. {
  81.     Ptr                    SndBuffer;
  82.     short                *VolPtr, *VolPtr2;
  83.     long                LRVol = intDriver->LeftRight[ curVoice->ID];
  84.     Byte                tByte = 0;
  85.     long                off, i = intDriver->ASCBUFFER;
  86.     
  87.     ///
  88.     long                aDD, aCC = curVoice->lAC;
  89.     
  90.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  91.     ///
  92.     
  93.     //*****************************************
  94.     //*****************************************
  95.     //*****************************************
  96.     if( intDriver->DriverSettings.TickRemover) MADTickRemoverStart8( curVoice, ASCBuffer, ASCBuffer+1, intDriver);
  97.     //*****************************************
  98.     //*****************************************
  99.     //*****************************************
  100.     
  101.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  102.     
  103.     SndBuffer        = curVoice->curPtr;
  104.     VolPtr2            = (short*) ( intDriver->Vol + (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8) * 2L);
  105.     LRVol = 100 - LRVol;
  106.     VolPtr            = (short*) ( intDriver->Vol + (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8) * 2L);
  107.     
  108.     if( SndBuffer + 1 + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  109.     {
  110.         if( intDriver->DriverSettings.Interpolation)
  111.         {
  112.             long    RightWeight, LeftWeight;
  113.             
  114.             while( i-- > 0)
  115.             {
  116.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  117.                 
  118.                 off = (aCC>>BYTEDIV);
  119.                 if( SndBuffer + off + 1 >= curVoice->maxPtr)
  120.                 {
  121.                     if( curVoice->loopSize > 0) 
  122.                     {
  123.                         long    before;
  124.                         
  125.                         if( i >= intDriver->ASCBUFFER-1)
  126.                         {
  127.                             before = curVoice->lastWord >> 8;
  128.                         }
  129.                         else
  130.                         {
  131.                             aCC -= aDD;
  132.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  133.                             aCC += aDD;
  134.                         }
  135.                         
  136.                         SndBuffer -= curVoice->loopSize;
  137.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  138.                         
  139.                         //*****************************************
  140.                         //*****************************************
  141.                         //*****************************************
  142.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop8( i, curVoice, ASCBuffer, ASCBuffer+1, intDriver, before - *(SndBuffer + off));
  143.                         //*****************************************
  144.                         //*****************************************
  145.                         //*****************************************
  146.                         
  147.                     }
  148.                     else    // If TICK remove
  149.                     {
  150.                         
  151.                         //*****************************************
  152.                         //*****************************************
  153.                         //*****************************************
  154.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer, ASCBuffer+1, i, *(VolPtr + tByte), *(VolPtr2 + tByte));
  155.                         //*****************************************
  156.                         //*****************************************
  157.                         //*****************************************
  158.                         
  159.                         break;
  160.                     }
  161.                 }
  162.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  163.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  164.                 
  165.                 *ASCBuffer++ += *(VolPtr + tByte);
  166.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  167.             }
  168.         }
  169.         else
  170.         {
  171.             while( i-- > 0)
  172.             {
  173.                 off = (aCC>>BYTEDIV);
  174.                 if( SndBuffer + off >= curVoice->maxPtr)
  175.                 {
  176.                     if( curVoice->loopSize > 0) 
  177.                     {
  178.                         long    before;
  179.                         
  180.                         if( i >= intDriver->ASCBUFFER-1) before = curVoice->lastWord >> 8;
  181.                         else
  182.                         {
  183.                             aCC -= aDD;
  184.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  185.                             aCC += aDD;
  186.                         }
  187.                         
  188.                         SndBuffer -= curVoice->loopSize;
  189.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  190.                         
  191.                         //*****************************************
  192.                         //*****************************************
  193.                         //*****************************************
  194.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop8( i, curVoice, ASCBuffer, ASCBuffer+1, intDriver, before - *(SndBuffer + off));
  195.                         //*****************************************
  196.                         //*****************************************
  197.                         //*****************************************
  198.                     }
  199.                     else    // If TICK remove
  200.                     {
  201.                         //*****************************************
  202.                         //*****************************************
  203.                         //*****************************************
  204.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer, ASCBuffer+1, i, *(VolPtr + tByte), *(VolPtr2 + tByte));
  205.                         //*****************************************
  206.                         //*****************************************
  207.                         //*****************************************
  208.                         
  209.                         break;
  210.                     }
  211.                 }
  212.                 
  213.                 tByte = (Byte) *(SndBuffer + off);        aCC += aDD;
  214.                 *ASCBuffer++ += *(VolPtr + tByte);
  215.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  216.             }
  217.         }
  218.         
  219.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  220.         else
  221.         {
  222.             curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;
  223.         }
  224.     }
  225.     else
  226.     {
  227.         if( intDriver->DriverSettings.Interpolation)
  228.         {
  229.             long    RightWeight, LeftWeight;
  230.             
  231.             while( i-- > 0)
  232.             {
  233.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  234.                 
  235.                 off = (aCC>>BYTEDIV);
  236.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  237.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  238.                 
  239.                 *ASCBuffer++ += *(VolPtr + tByte);
  240.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  241.             }
  242.         }
  243.         else
  244.         {
  245.             while( i-- > 0)
  246.             {
  247.                 off = aCC>>BYTEDIV;
  248.                 tByte = (Byte) *(SndBuffer + off);            aCC += aDD;
  249.                 *ASCBuffer++ += *(VolPtr + tByte);
  250.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  251.             }
  252.         }
  253.         
  254.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  255.     }
  256.     
  257.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  258.     
  259.     aCC -= aDD;
  260.     curVoice->lastWord = *(SndBuffer + (long) (aCC>>BYTEDIV));
  261.     curVoice->lastWord <<= 8;
  262. }
  263.  
  264. void Sampler16Addin16Deluxe( Channel *curVoice, register long    *ASCBuffer, MADDriverRec *intDriver)
  265. {
  266.     long                i = intDriver->ASCBUFFER;
  267.     short                *SndBuffer, tShort;
  268.     long                LRVol = intDriver->LeftRight[ curVoice->ID], chnVol, chnVol2;
  269.     long                off;
  270.     
  271.     ///
  272.     long                aDD, aCC = curVoice->lAC;
  273.     
  274.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  275.     ///
  276.     
  277.     //*****************************************
  278.     //*****************************************
  279.     //*****************************************
  280.     if( intDriver->DriverSettings.TickRemover) MADTickRemoverStart8( curVoice, ASCBuffer, ASCBuffer+1, intDriver);
  281.     //*****************************************
  282.     //*****************************************
  283.     //*****************************************
  284.     
  285.     
  286.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  287.     
  288.     SndBuffer        = (short*)    curVoice->curPtr;
  289.     
  290.     chnVol2        = ((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ REDUCEVOLUME);
  291.     LRVol = 100 - LRVol;
  292.     chnVol         = ((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ REDUCEVOLUME);
  293.     
  294.     if( SndBuffer + 1L + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= (  short*) curVoice->maxPtr)
  295.     {
  296.         if( intDriver->DriverSettings.Interpolation)
  297.         {
  298.             long    RightWeight, LeftWeight;
  299.             
  300.             while( i-- > 0)
  301.             {
  302.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  303.                 
  304.                 off = (aCC>>BYTEDIV);
  305.                 if( SndBuffer + off + 1 >= (short*) curVoice->maxPtr)
  306.                 {
  307.                     if( curVoice->loopSize > 0) 
  308.                     {
  309.                         long    before;
  310.                         
  311.                         if( i >= intDriver->ASCBUFFER-1)
  312.                         {
  313.                             before = curVoice->lastWord;
  314.                         }
  315.                         else
  316.                         {
  317.                             aCC -= aDD;
  318.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  319.                             aCC += aDD;
  320.                         }
  321.                         
  322.                         SndBuffer -= curVoice->loopSize/2;
  323.                         if( SndBuffer + off < (short*) curVoice->begPtr) SndBuffer = (short*) curVoice->begPtr - off;
  324.                         
  325.                         //*****************************************
  326.                         //*****************************************
  327.                         //*****************************************
  328.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop16( i, curVoice, ASCBuffer, ASCBuffer+1, intDriver, before - *(SndBuffer + off));
  329.                         //*****************************************
  330.                         //*****************************************
  331.                         //*****************************************
  332.                         
  333.                     }
  334.                     else    // If TICK remove
  335.                     {
  336.                         
  337.                         //*****************************************
  338.                         //*****************************************
  339.                         //*****************************************
  340.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer, ASCBuffer+1, i, (tShort * chnVol) >> 6, (tShort * chnVol2) >> 6);
  341.                         //*****************************************
  342.                         //*****************************************
  343.                         //*****************************************
  344.                         
  345.                         break;
  346.                     }
  347.                 }
  348.                 tShort = (    LeftWeight *     *(SndBuffer + off) +
  349.                                         RightWeight *    *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  350.                 
  351.                 *ASCBuffer++ += (tShort * chnVol) >> 6;
  352.                 *ASCBuffer++ += (tShort * chnVol2) >> 6;
  353.             }
  354.         }
  355.         else
  356.         {
  357.             while( i-- > 0)
  358.             {
  359.                 off = (aCC>>BYTEDIV);
  360.                 if( SndBuffer + off >= (short*) curVoice->maxPtr)
  361.                 {
  362.                     if( curVoice->loopSize > 0) 
  363.                     {
  364.                         long    before;
  365.                         
  366.                         if( i >= intDriver->ASCBUFFER-1)
  367.                         {
  368.                             before = curVoice->lastWord;
  369.                         }
  370.                         else
  371.                         {
  372.                             aCC -= aDD;
  373.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  374.                             aCC += aDD;
  375.                         }
  376.                         
  377.                         SndBuffer -= curVoice->loopSize/2;
  378.                         if( SndBuffer + off < (short*) curVoice->begPtr) SndBuffer = (short*) curVoice->begPtr - off;
  379.                         
  380.                         //*****************************************
  381.                         //*****************************************
  382.                         //*****************************************
  383.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop16( i, curVoice, ASCBuffer, ASCBuffer+1, intDriver, before - *(SndBuffer + off));
  384.                         //*****************************************
  385.                         //*****************************************
  386.                         //*****************************************
  387.                         
  388.                     }
  389.                     else    // If TICK remove
  390.                     {
  391.                         
  392.                         //*****************************************
  393.                         //*****************************************
  394.                         //*****************************************
  395.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer, ASCBuffer+1, i, (tShort * chnVol) >> 6, (tShort * chnVol2) >> 6);
  396.                         //*****************************************
  397.                         //*****************************************
  398.                         //*****************************************
  399.                         
  400.                         break;
  401.                     }
  402.                 }
  403.                 tShort = *(SndBuffer + off);        aCC += aDD;
  404.                 
  405.                 *ASCBuffer++ += (tShort * chnVol) >> 6;
  406.                 *ASCBuffer++ += (tShort * chnVol2) >> 6;
  407.             }
  408.         }
  409.         
  410.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  411.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  412.     }
  413.     else
  414.     {
  415.         if( intDriver->DriverSettings.Interpolation)
  416.         {
  417.             long    RightWeight, LeftWeight;
  418.             
  419.             while( i-- > 0)
  420.             {
  421.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  422.                 
  423.                 off = (aCC>>BYTEDIV);
  424.                 tShort = (    LeftWeight *     *(SndBuffer + off) +
  425.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  426.             
  427.                 *ASCBuffer++ += (tShort * chnVol) >> 6;
  428.                 *ASCBuffer++ += (tShort * chnVol2) >> 6;
  429.             }
  430.         }
  431.         else
  432.         {
  433.             while( i-- > 0)
  434.             {
  435.                 off = (aCC>>BYTEDIV);
  436.                 tShort = *(SndBuffer + off);        aCC += aDD;
  437.                 
  438.                 *ASCBuffer++ += (tShort * chnVol) >> 6;
  439.                 *ASCBuffer++ += (tShort * chnVol2) >> 6;
  440.             }
  441.         }
  442.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  443.     }
  444.     
  445.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  446.     
  447.     aCC -= aDD;
  448.     curVoice->lastWord = *(SndBuffer + (long) (aCC>>BYTEDIV));
  449. }
  450.  
  451. void Sample16BufferAddDeluxe( Channel *curVoice, register long    *ASCBuffer, MADDriverRec *intDriver)
  452. {
  453. //    if( curVoice->period == 0) Debugger();
  454.     if( curVoice->amp == 16) Sampler16Addin16Deluxe( curVoice, ASCBuffer, intDriver);
  455.     else if( curVoice->amp == 8) Sampler16AddDeluxe( curVoice, ASCBuffer, intDriver);
  456. }
  457.  
  458. void Play16StereoDeluxe( MADDriverRec *intDriver)
  459. {
  460. short        *ASCBuffer, valP = 0x7FFFL, valN = -0x7FFFL;
  461. long        *ttt, i;
  462.  
  463.     for( i = 0 ; i < intDriver->DriverSettings.numChn; i++) Sample16BufferAddDeluxe( &intDriver->chan[ i], intDriver->DASCBuffer, intDriver);
  464.     
  465.     ttt = intDriver->DASCBuffer;
  466.     ASCBuffer = (short*) intDriver->IntDataPtr;
  467.     
  468.     i = intDriver->ASCBUFFER*2;
  469.     
  470.     while( i-- > 0)
  471.     {
  472.         if( *ttt > valP) *ASCBuffer++ = valP;
  473.         else if( *ttt < valN) *ASCBuffer++ = valN;
  474.         else *ASCBuffer++ = *ttt;
  475.         
  476.         *ttt++ = 0;
  477.     }
  478. }
  479.  
  480. void Sampler8in8AddDeluxe( Channel *curVoice, register short    *ASCBuffer, MADDriverRec *intDriver)
  481. {
  482.     char             *SndBuffer;
  483.     Byte            tByte;
  484.     long             i = intDriver->ASCBUFFER, LRVol = intDriver->LeftRight[ curVoice->ID];
  485.     Ptr                VolPtr, VolPtr2;
  486.     long            off;
  487.  
  488.     ///
  489.     long                aDD, aCC = curVoice->lAC;
  490.     
  491.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  492.     ///
  493.     
  494.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  495.     
  496.     SndBuffer        = (char*)     curVoice->curPtr;
  497.     
  498.     VolPtr2            = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  499.     LRVol = 100 - LRVol;
  500.     VolPtr             = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  501.  
  502.     if( (Ptr) SndBuffer + 1L + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  503.     {
  504.         if( intDriver->DriverSettings.Interpolation)
  505.         {
  506.             long    RightWeight, LeftWeight;
  507.             
  508.             while( i-- > 0)
  509.             {
  510.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  511.                 
  512.                 off = aCC>>BYTEDIV;
  513.                 if( SndBuffer + off + 1L >= (char*) curVoice->maxPtr)
  514.                 {
  515.                     if( curVoice->loopSize > 0) 
  516.                     {
  517.                         SndBuffer -= curVoice->loopSize;
  518.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  519.                     }
  520.                     else break;
  521.                 }
  522.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  523.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  524.                 
  525.                 *ASCBuffer++ += *(VolPtr + tByte);
  526.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  527.             }
  528.         }
  529.         else
  530.         {
  531.             while( i-- > 0)
  532.             {
  533.                 off = aCC>>BYTEDIV;
  534.                 if( SndBuffer + off + 1L >= (char*) curVoice->maxPtr)
  535.                 {
  536.                     if( curVoice->loopSize > 0) 
  537.                     {
  538.                         SndBuffer -= curVoice->loopSize;
  539.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  540.                     }
  541.                     else break;
  542.                 }
  543.                 tByte =    *(SndBuffer + off);            aCC += aDD;
  544.             
  545.                 *ASCBuffer++ += *(VolPtr + tByte);
  546.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  547.             }
  548.         }
  549.         
  550.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  551.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  552.     }
  553.     else
  554.     {
  555.         if( intDriver->DriverSettings.Interpolation)
  556.         {
  557.             long    RightWeight, LeftWeight;
  558.             
  559.             while( i-- > 0)
  560.             {
  561.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  562.                 
  563.                 off = aCC>>BYTEDIV;
  564.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  565.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  566.             
  567.                 *ASCBuffer++ += *(VolPtr + tByte);
  568.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  569.             }
  570.         }
  571.         else
  572.         {
  573.             while( i-- > 0)
  574.             {
  575.                 off = aCC>>BYTEDIV;
  576.                 tByte =    *(SndBuffer + off);            aCC += aDD;
  577.             
  578.                 *ASCBuffer++ += *(VolPtr + tByte);
  579.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  580.             }
  581.         }
  582.         
  583.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  584.     }
  585.     
  586.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  587. }
  588.  
  589. void Sampler8in16AddDeluxe( Channel *curVoice, register short    *ASCBuffer, MADDriverRec *intDriver)
  590. {
  591.     char                 *SndBuffer;
  592.     Byte                tByte;
  593.     Ptr                    VolPtr, VolPtr2;
  594.     long                i = intDriver->ASCBUFFER, LRVol = intDriver->LeftRight[ curVoice->ID];
  595.     long                off;
  596.     
  597.     ///
  598.     long                aDD, aCC = curVoice->lAC;
  599.     
  600.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  601.     ///
  602.  
  603.     
  604.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  605.     
  606.     SndBuffer        = (char*) curVoice->curPtr;
  607.  
  608.     
  609.     VolPtr2            = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  610.     LRVol = 100 - LRVol;
  611.     VolPtr             = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  612.     
  613.     if( (Ptr) SndBuffer + 2L + 2*(long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  614.     {
  615.         if( intDriver->DriverSettings.Interpolation)
  616.         {
  617.             long    RightWeight, LeftWeight;
  618.             
  619.             while( i-- > 0)
  620.             {
  621.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  622.                 
  623.                 off = aCC>>BYTEDIV;
  624.                 if( SndBuffer + 2*off + 2L >= (char*) curVoice->maxPtr)
  625.                 {
  626.                     if( curVoice->loopSize > 0) 
  627.                     {
  628.                         SndBuffer -= curVoice->loopSize;
  629.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  630.                     }
  631.                     else break;
  632.                 }
  633.                 tByte = (    LeftWeight *     *(SndBuffer + 2*off) +
  634.                             RightWeight *     *(SndBuffer + 2*off + 2)) >> BYTEDIV;            aCC += aDD;
  635.             
  636.                 *ASCBuffer++ += *(VolPtr + tByte);
  637.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  638.             }
  639.         }
  640.         else
  641.         {
  642.             while( i-- > 0)
  643.             {
  644.                 off = aCC>>BYTEDIV;
  645.                 if( SndBuffer + 2*off + 2L >= (char*) curVoice->maxPtr)
  646.                 {
  647.                     if( curVoice->loopSize > 0) 
  648.                     {
  649.                         SndBuffer -= curVoice->loopSize;
  650.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  651.                     }
  652.                     else break;
  653.                 }
  654.                 tByte =    *(SndBuffer + 2*off);            aCC += aDD;
  655.                 
  656.                 *ASCBuffer++ += *(VolPtr + tByte);
  657.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  658.             }
  659.         }
  660.         
  661.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) 2*(long) (aCC>>BYTEDIV));
  662.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  663.     }
  664.     else
  665.     {
  666.         if( intDriver->DriverSettings.Interpolation)
  667.         {
  668.             long    RightWeight, LeftWeight;
  669.             
  670.             while( i-- > 0)
  671.             {
  672.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  673.                 
  674.                 off = aCC>>BYTEDIV;
  675.                 tByte = (    LeftWeight *     *(SndBuffer + 2*off) +
  676.                             RightWeight *     *(SndBuffer + 2*off + 2)) >> BYTEDIV;            aCC += aDD;
  677.             
  678.                 *ASCBuffer++ += *(VolPtr + tByte);
  679.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  680.             }
  681.         }
  682.         else
  683.         {
  684.             while( i-- > 0)
  685.             {
  686.                 off = aCC>>BYTEDIV;
  687.                 tByte =    *(SndBuffer + 2*off);            aCC += aDD;
  688.                 
  689.                 *ASCBuffer++ += *(VolPtr + tByte);
  690.                 *ASCBuffer++ += *(VolPtr2 + tByte);
  691.             }
  692.         }
  693.         
  694.         curVoice->curPtr = (Ptr) (SndBuffer + 2*(long) (aCC>>BYTEDIV));
  695.     }
  696.     
  697.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  698. }
  699.  
  700. void Sample8BufferAddDeluxe( Channel *curVoice, register short *ASCBuffer, MADDriverRec *intDriver)
  701. {
  702.     if( curVoice->amp == 16) Sampler8in16AddDeluxe( curVoice, ASCBuffer, intDriver);
  703.     else Sampler8in8AddDeluxe( curVoice, ASCBuffer, intDriver);
  704. }
  705.  
  706. void Play8StereoDeluxe( MADDriverRec *intDriver)
  707. {
  708. long            i;
  709. short            *ttt;
  710. Ptr                ASCBuffer;
  711.  
  712.     for( i = 0 ; i < intDriver->DriverSettings.numChn; i++) Sample8BufferAddDeluxe    ( &intDriver->chan[i], intDriver->DASCBuffer8, intDriver);
  713.  
  714.     ttt = intDriver->DASCBuffer8;
  715.     ASCBuffer = intDriver->IntDataPtr;
  716.  
  717.     i = intDriver->ASCBUFFER*2;
  718.     while( i-- > 0)
  719.     {
  720.         *ASCBuffer++ = *(intDriver->OverShoot + *ttt);
  721.         *ttt++ = 0;
  722.     }
  723. }
  724.